package view;

import model.Department;
import model.Major;
import service.DepartmentService;
import service.MajorService;
import javax.swing.*;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.util.List;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.table.TableColumn;
import javax.swing.table.TableRowSorter;
import javax.swing.RowFilter;

/**
 * 该类是一个用于管理系部和专业关系的面板。
 * 它继承自JPanel，使用Swing组件来创建图形用户界面。
 * 用户可以通过该面板添加、编辑、删除系部，以及为系部分配和移除专业。
 */
public class DepartmentManagementPanel extends JPanel {
    // 定义字体常量，用于界面中标题和内容的显示
    private static final Font TITLE_FONT = new Font("微软雅黑", Font.BOLD, 14);
    private static final Font CONTENT_FONT = new Font("微软雅黑", Font.PLAIN, 13);
    private static final Font BUTTON_FONT = new Font("微软雅黑", Font.PLAIN, 13);

    // 服务类实例，用于访问和操作系部与专业数据
    private DepartmentService departmentService;
    private MajorService majorService;

    // JTable实例，用于显示系部和专业信息
    private JTable departmentTable;
    private DefaultTableModel departmentTableModel;
    private JTable majorTable;
    private DefaultTableModel majorTableModel;

    // 当前选中的系部代码
    private String selectedDeptCode;

    /**
     * 构造方法，初始化服务类和组件。
     */
    public DepartmentManagementPanel() {
        this.departmentService = new DepartmentService();
        this.majorService = new MajorService();
        initComponents(); // 初始化界面组件
        loadData(); // 加载数据到表格
    }

    /**
     * 初始化界面组件，设置布局，创建和配置JSplitPane、JPanel、JTable、JToolBar等。
     */
    private void initComponents() {
        setLayout(new BorderLayout()); // 设置面板布局为BorderLayout

        // 创建分割面板
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
        splitPane.setDividerLocation(500); // 设置分割线位置

        // 左侧系部管理面板
        JPanel deptPanel = createDepartmentPanel();
        splitPane.setLeftComponent(deptPanel); // 设置左侧组件为系部管理面板

        // 右侧专业管理面板
        JPanel majorPanel = createMajorPanel();
        splitPane.setRightComponent(majorPanel); // 设置右侧组件为专业管理面板

        add(splitPane, BorderLayout.CENTER); // 将分割面板添加到中心区域
    }

    /**
     * 创建系部管理面板，包含工具栏和系部信息表格。
     * @return 返回创建好的系部管理面板。
     */
    private JPanel createDepartmentPanel() {
        JPanel panel = new JPanel(new BorderLayout());
        // 设置面板边框，包含标题“系部管理”
        panel.setBorder(BorderFactory.createTitledBorder(
                BorderFactory.createEtchedBorder(),
                "系部管理",
                TitledBorder.LEFT,
                TitledBorder.TOP,
                TITLE_FONT
        ));

        // 工具栏
        JToolBar toolBar = new JToolBar();
        toolBar.setFloatable(false);

        // 创建工具栏按钮：添加系部、编辑系部、删除系部
        JButton addButton = new JButton("添加系部");
        JButton editButton = new JButton("编辑系部");
        JButton deleteButton = new JButton("删除系部");

        // 设置按钮字体
        addButton.setFont(BUTTON_FONT);
        editButton.setFont(BUTTON_FONT);
        deleteButton.setFont(BUTTON_FONT);

        // 将按钮添加到工具栏
        toolBar.add(addButton);
        toolBar.add(editButton);
        toolBar.add(deleteButton);

        // 将工具栏添加到面板的顶部
        panel.add(toolBar, BorderLayout.NORTH);

        // 创建系部信息表格
        String[] columnNames = {"系部代码", "系部名称", "描述"};
        departmentTableModel = new DefaultTableModel(columnNames, 0) {
            @Override
            public boolean isCellEditable(int row, int column) {
                return false; // 表格单元格不可编辑
            }
        };

        departmentTable = new JTable(departmentTableModel);
        // 设置表格字体和行高
        departmentTable.setFont(CONTENT_FONT);
        departmentTable.getTableHeader().setFont(TITLE_FONT);
        departmentTable.setRowHeight(25);

        // 为按钮添加事件监听器
        addButton.addActionListener(e -> showAddDepartmentDialog());
        editButton.addActionListener(e -> editSelectedDepartment());
        deleteButton.addActionListener(e -> deleteSelectedDepartment());

        // 添加表格选择监听器，当选择系部时更新专业表格
        departmentTable.getSelectionModel().addListSelectionListener(e -> {
            if (!e.getValueIsAdjusting()) {
                updateMajorTable();
            }
        });

        JScrollPane scrollPane = new JScrollPane(departmentTable);
        // 将带有滚动条的系部表格添加到面板
        panel.add(scrollPane, BorderLayout.CENTER);

        return panel;
    }

    /**
     * 创建专业管理面板，包含工具栏和专业信息表格。
     * @return 返回创建好的专业管理面板。
     */
    private JPanel createMajorPanel() {
        JPanel panel = new JPanel(new BorderLayout());
        // 设置面板边框，包含标题“专业管理”
        panel.setBorder(BorderFactory.createTitledBorder(
                BorderFactory.createEtchedBorder(),
                "专业管理",
                TitledBorder.LEFT,
                TitledBorder.TOP,
                TITLE_FONT
        ));

        // 工具栏
        JToolBar toolBar = new JToolBar();
        toolBar.setFloatable(false);

        // 创建工具栏按钮：分配专业
        JButton assignButton = new JButton("分配专业");
        assignButton.setFont(BUTTON_FONT);
        toolBar.add(assignButton);

        // 将工具栏添加到面板的顶部
        panel.add(toolBar, BorderLayout.NORTH);

        // 创建专业信息表格
        String[] majorColumnNames = {"专业代码", "专业名称", "操作"};
        majorTableModel = new DefaultTableModel(majorColumnNames, 0) {
            @Override
            public boolean isCellEditable(int row, int column) {
                return column == 2; // 只有操作列可编辑
            }
        };

        majorTable = new JTable(majorTableModel);
        // 设置表格字体、行高和选择模式
        majorTable.setFont(CONTENT_FONT);
        majorTable.getTableHeader().setFont(TITLE_FONT);
        majorTable.setRowHeight(35);
        majorTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        // 设置操作列的渲染器和编辑器
        TableColumn operationColumn = majorTable.getColumnModel().getColumn(2);
        operationColumn.setCellRenderer(new view.common.ButtonRenderer());
        operationColumn.setCellEditor(new view.common.ButtonEditor(e -> {
            int row = majorTable.getSelectedRow();
            if (row >= 0) {
                row = majorTable.convertRowIndexToModel(row);
                String majorCode = (String) majorTableModel.getValueAt(row, 0);
                String majorName = (String) majorTableModel.getValueAt(row, 1);
                String action = e.getActionCommand();

                // 当点击“删除”按钮时，确认是否将专业从当前系部中移除
                if ("删除".equals(action)) {
                    int choice = JOptionPane.showConfirmDialog(
                            this,
                            "确定要将专业 '" + majorName + "' 从当前系部中移除吗？",
                            "确认移除",
                            JOptionPane.YES_NO_OPTION,
                            JOptionPane.WARNING_MESSAGE
                    );

                    // 如果用户确认删除，则尝试移除专业
                    if (choice == JOptionPane.YES_OPTION) {
                        if (departmentService.removeMajorFromDepartment(majorCode)) {
                            loadMajorData(selectedDeptCode, majorTableModel); // 更新专业表格数据
                            JOptionPane.showMessageDialog(this, "专业移除成功！"); // 显示成功消息
                        } else {
                            JOptionPane.showMessageDialog(this,
                                    "专业移除失败！",
                                    "错误",
                                    JOptionPane.ERROR_MESSAGE); // 显示失败消息
                        }
                    }
                }
            }
        }));

        // 设置操作列的宽度
        operationColumn.setPreferredWidth(100);
        operationColumn.setMinWidth(100);

        // 设置其他列的宽度
        int[] majorColumnWidths = {120, 200, 100};
        for (int i = 0; i < majorColumnWidths.length; i++) {
            TableColumn column = majorTable.getColumnModel().getColumn(i);
            column.setPreferredWidth(majorColumnWidths[i]);
        }

        // 为分配专业按钮添加事件监听器
        assignButton.addActionListener(e -> showAssignMajorDialog());

        JScrollPane scrollPane = new JScrollPane(majorTable);
        // 将带有滚动条的专业表格添加到面板
        panel.add(scrollPane, BorderLayout.CENTER);

        return panel;
    }

    /**
     * 加载数据，首先加载系部数据，专业数据则根据选择的系部来加载。
     */
    private void loadData() {
        loadDepartmentData(); // 加载系部数据到表格
        // 初始时不显示任何专业
        majorTableModel.setRowCount(0);
    }

    /**
     * 加载所有系部数据到系部表格。
     */
    private void loadDepartmentData() {
        departmentTableModel.setRowCount(0); // 清空表格
        List<Department> departments = departmentService.getAllDepartments(); // 获取所有系部
        for (Department dept : departments) {
            Object[] rowData = {
                    dept.getDeptCode(),
                    dept.getDeptName(),
                    dept.getDescription()
            };
            departmentTableModel.addRow(rowData); // 将系部信息添加到表格
        }
    }

    /**
     * 更新专业表格，根据当前选择的系部加载相关专业信息。
     */
    private void updateMajorTable() {
        int selectedRow = departmentTable.getSelectedRow(); // 获取选中的行
        if (selectedRow == -1) return; // 如果没有选中任何行，直接返回

        String deptCode = (String) departmentTable.getValueAt(selectedRow, 0); // 获取系部代码
        selectedDeptCode = deptCode;  // 保存当前选中的系部代码
        updateMajorTable(deptCode); // 调用内部方法更新专业表格
    }

    /**
     * 根据系部代码加载该系部下的所有专业数据到专业表格。
     * @param deptCode 系部代码
     */
    private void updateMajorTable(String deptCode) {
        majorTableModel.setRowCount(0); // 清空专业表格
        if (deptCode != null) {
            List<Major> majors = departmentService.getDepartmentMajors(deptCode); // 获取该系部下的所有专业
            for (Major major : majors) {
                Object[] rowData = {
                        major.getMajorCode(),
                        major.getMajorName(),
                        "移除"
                };
                majorTableModel.addRow(rowData); // 将专业信息添加到表格
            }
        }
    }

    /**
     * 显示添加系部对话框，允许用户输入新的系部信息。
     */
    private void showAddDepartmentDialog() {
        // 创建模态对话框，父窗口为当前面板所在的窗口
        JDialog dialog = new JDialog((Frame)SwingUtilities.getWindowAncestor(this),
                "添加系部", true);
        dialog.setLayout(new BorderLayout(10, 10));

        // 创建表单面板
        JPanel formPanel = new JPanel(new GridBagLayout());
        formPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(5, 5, 5, 5);
        gbc.fill = GridBagConstraints.HORIZONTAL;

        // 创建输入组件：系部代码、系部名称、描述
        JTextField codeField = new JTextField(20);
        JTextField nameField = new JTextField(20);
        JTextArea descArea = new JTextArea(3, 20);
        descArea.setLineWrap(true);
        JScrollPane descScroll = new JScrollPane(descArea);

        // 设置组件大小
        Dimension fieldSize = new Dimension(250, 30);
        codeField.setPreferredSize(fieldSize);
        nameField.setPreferredSize(fieldSize);

        // 设置字体
        codeField.setFont(CONTENT_FONT);
        nameField.setFont(CONTENT_FONT);
        descArea.setFont(CONTENT_FONT);

        // 将输入组件添加到表单面板
        int row = 0;
        addFormField(formPanel, "系部代码：", codeField, gbc, row++);
        addFormField(formPanel, "系部名称：", nameField, gbc, row++);
        addFormField(formPanel, "描述：", descScroll, gbc, row++);

        // 将表单面板添加到对话框
        dialog.add(formPanel, BorderLayout.CENTER);

        // 创建按钮面板，包含保存和取消按钮
        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 10));
        JButton saveButton = new JButton("保存");
        JButton cancelButton = new JButton("取消");

        // 设置按钮大小和字体
        Dimension buttonSize = new Dimension(90, 32);
        saveButton.setPreferredSize(buttonSize);
        cancelButton.setPreferredSize(buttonSize);
        saveButton.setFont(BUTTON_FONT);
        cancelButton.setFont(BUTTON_FONT);

        // 为保存按钮添加事件监听器，保存用户输入的信息到数据库
        saveButton.addActionListener(e -> {
            String code = codeField.getText().trim(); // 获取系部代码
            String name = nameField.getText().trim(); // 获取系部名称
            String description = descArea.getText().trim(); // 获取描述

            // 如果系部代码或名称为空，提示用户填写必要信息
            if (code.isEmpty() || name.isEmpty()) {
                JOptionPane.showMessageDialog(dialog, "请填写必要信息！");
                return;
            }

            // 创建新的Department对象并设置属性
            Department dept = new Department();
            dept.setDeptCode(code);
            dept.setDeptName(name);
            dept.setDescription(description);

            // 尝试添加系部到数据库，成功则刷新系部表格并显示成功消息；失败则显示错误消息
            if (departmentService.createDepartment(dept)) {
                dialog.dispose(); // 关闭对话框
                loadDepartmentData(); // 刷新系部表格
                JOptionPane.showMessageDialog(this, "系部添加成功！");
            } else {
                JOptionPane.showMessageDialog(dialog, "系部添加失败！",
                        "错误", JOptionPane.ERROR_MESSAGE);
            }
        });

        // 为取消按钮添加事件监听器，关闭对话框
        cancelButton.addActionListener(e -> dialog.dispose());

        // 将按钮面板添加到对话框的底部
        buttonPanel.add(saveButton);
        buttonPanel.add(cancelButton);
        dialog.add(buttonPanel, BorderLayout.SOUTH);

        // 设置对话框大小和位置，并显示对话框
        dialog.setSize(400, 300);
        dialog.setLocationRelativeTo(this);
        dialog.setVisible(true);
    }

    /**
     * 显示编辑系部对话框，允许用户修改已选系部的信息。
     */
    private void editSelectedDepartment() {
        int selectedRow = departmentTable.getSelectedRow(); // 获取选中的行
        if (selectedRow == -1) {
            // 如果没有选中任何行，提示用户选择要编辑的系部
            JOptionPane.showMessageDialog(this, "请选择要编辑的系部！");
            return;
        }

        String deptCode = (String) departmentTable.getValueAt(selectedRow, 0); // 获取系部代码
        Department dept = departmentService.getDepartmentByCode(deptCode); // 根据系部代码获取系部信息

        if (dept == null) {
            // 如果获取系部信息失败，显示错误消息
            JOptionPane.showMessageDialog(this, "获取系部信息失败！",
                    "错误", JOptionPane.ERROR_MESSAGE);
            return;
        }

        showEditDepartmentDialog(dept); // 显示编辑系部对话框
    }

    /**
     * 显示编辑系部对话框，用户可以在该对话框中修改系部信息。
     * @param dept 要编辑的系部对象。
     */
    private void showEditDepartmentDialog(Department dept) {
        // 创建模态对话框，父窗口为当前面板所在的窗口
        JDialog dialog = new JDialog((Frame)SwingUtilities.getWindowAncestor(this),
                "编辑系部", true);
        dialog.setLayout(new BorderLayout(10, 10));

        // 创建表单面板
        JPanel formPanel = new JPanel(new GridBagLayout());
        formPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(5, 5, 5, 5);
        gbc.fill = GridBagConstraints.HORIZONTAL;

        // 创建输入组件：系部代码、系部名称、描述
        JTextField codeField = new JTextField(dept.getDeptCode(), 20);
        JTextField nameField = new JTextField(dept.getDeptName(), 20);
        JTextArea descArea = new JTextArea(dept.getDescription(), 3, 20);
        descArea.setLineWrap(true);
        JScrollPane descScroll = new JScrollPane(descArea);

        // 设置组件大小
        Dimension fieldSize = new Dimension(250, 30);
        codeField.setPreferredSize(fieldSize);
        nameField.setPreferredSize(fieldSize);

        // 设置字体
        codeField.setFont(CONTENT_FONT);
        nameField.setFont(CONTENT_FONT);
        descArea.setFont(CONTENT_FONT);

        // 系部代码不可编辑
        codeField.setEditable(false);

        // 将输入组件添加到表单面板
        int row = 0;
        addFormField(formPanel, "系部代码：", codeField, gbc, row++);
        addFormField(formPanel, "系部名称：", nameField, gbc, row++);
        addFormField(formPanel, "描述：", descScroll, gbc, row++);

        // 将表单面板添加到对话框
        dialog.add(formPanel, BorderLayout.CENTER);

        // 创建按钮面板，包含保存和取消按钮
        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 10));
        JButton saveButton = new JButton("保存");
        JButton cancelButton = new JButton("取消");

        // 设置按钮大小和字体
        Dimension buttonSize = new Dimension(90, 32);
        saveButton.setPreferredSize(buttonSize);
        cancelButton.setPreferredSize(buttonSize);
        saveButton.setFont(BUTTON_FONT);
        cancelButton.setFont(BUTTON_FONT);

        // 为保存按钮添加事件监听器，更新用户修改的信息到数据库
        saveButton.addActionListener(e -> {
            String name = nameField.getText().trim(); // 获取系部名称
            String description = descArea.getText().trim(); // 获取描述

            // 如果系部名称为空，提示用户填写系部名称
            if (name.isEmpty()) {
                JOptionPane.showMessageDialog(dialog, "请填写系部名称！");
                return;
            }

            // 更新Department对象的属性
            dept.setDeptName(name);
            dept.setDescription(description);

            // 尝试更新系部信息到数据库，成功则刷新系部表格并显示成功消息；失败则显示错误消息
            if (departmentService.updateDepartment(dept)) {
                dialog.dispose(); // 关闭对话框
                loadDepartmentData(); // 刷新系部表格
                JOptionPane.showMessageDialog(this, "系部更新成功！");
            } else {
                JOptionPane.showMessageDialog(dialog, "系部更新失败！",
                        "错误", JOptionPane.ERROR_MESSAGE);
            }
        });

        // 为取消按钮添加事件监听器，关闭对话框
        cancelButton.addActionListener(e -> dialog.dispose());

        // 将按钮面板添加到对话框的底部
        buttonPanel.add(saveButton);
        buttonPanel.add(cancelButton);
        dialog.add(buttonPanel, BorderLayout.SOUTH);

        // 设置对话框大小和位置，并显示对话框
        dialog.setSize(400, 300);
        dialog.setLocationRelativeTo(this);
        dialog.setVisible(true);
    }

    /**
     * 删除选中的系部，同时删除相关的专业关联。
     */
    private void deleteSelectedDepartment() {
        int selectedRow = departmentTable.getSelectedRow(); // 获取选中的行
        if (selectedRow == -1) {
            // 如果没有选中任何行，提示用户选择要删除的系部
            JOptionPane.showMessageDialog(this, "请选择要删除的系部！");
            return;
        }

        String deptCode = (String) departmentTable.getValueAt(selectedRow, 0); // 获取系部代码
        String deptName = (String) departmentTable.getValueAt(selectedRow, 1); // 获取系部名称

        // 显示确认对话框，询问用户是否确定删除该系部及其关联的专业
        int choice = JOptionPane.showConfirmDialog(
                this,
                "确定要删除系部 " + deptName + "（" + deptCode + "）吗？\n" +
                        "注意：删除系部将同时删除相关的专业关联！",
                "删除确认",
                JOptionPane.YES_NO_OPTION,
                JOptionPane.WARNING_MESSAGE
        );

        // 如果用户确认删除，则尝试删除系部及其关联的专业
        if (choice == JOptionPane.YES_OPTION) {
            if (departmentService.deleteDepartment(deptCode)) {
                loadDepartmentData(); // 刷新系部表格
                majorTableModel.setRowCount(0); // 清空专业表格
                JOptionPane.showMessageDialog(this, "系部删除成功！");
            } else {
                JOptionPane.showMessageDialog(this, "系部删除失败！",
                        "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    /**
     * 显示分配专业对话框，允许用户为选中的系部分配未分配的专业。
     */
    private void showAssignMajorDialog() {
        if (selectedDeptCode == null) {
            // 如果没有选中的系部，提示用户先选择一个系部
            JOptionPane.showMessageDialog(this, "请先选择一个系部！");
            return;
        }

        // 创建模态对话框，父窗口为当前面板所在的窗口
        JDialog dialog = new JDialog((Frame)SwingUtilities.getWindowAncestor(this),
                "分配专业", true);
        dialog.setLayout(new BorderLayout(10, 10));

        // 创建搜索面板，包含搜索框
        JPanel searchPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
        JTextField searchField = new JTextField(20);
        searchField.setPreferredSize(new Dimension(200, 30));
        searchField.setFont(CONTENT_FONT);
        searchPanel.add(new JLabel("搜索："));
        searchPanel.add(searchField);

        // 将搜索面板添加到对话框的顶部
        dialog.add(searchPanel, BorderLayout.NORTH);

        // 创建专业表格模型
        DefaultTableModel model = new DefaultTableModel(
                new String[]{"专业代码", "专业名称", "操作"}, 0
        ) {
            @Override
            public boolean isCellEditable(int row, int column) {
                return column == 2;
            }
        };

        // 创建专业表格
        JTable table = new JTable(model);
        // 设置表格字体和行高
        table.setFont(CONTENT_FONT);
        table.getTableHeader().setFont(TITLE_FONT);
        table.setRowHeight(25);

        // 加载所有未分配的专业数据到表格模型
        List<Major> allMajors = majorService.getAllMajors();
        for (Major major : allMajors) {
            if (major.getDeptCode() == null) {  // 只显示未分配的专业
                model.addRow(new Object[]{
                        major.getMajorCode(),
                        major.getMajorName(),
                        "添加"
                });
            }
        }

        // 创建按钮编辑器，用于专业表格的操作列
        ButtonEditor buttonEditor = new ButtonEditor(e -> {
            int row = table.getSelectedRow();
            if (row != -1) {
                row = table.convertRowIndexToModel(row);
                String majorCode = (String) model.getValueAt(row, 0);
                // 尝试将专业分配到选中的系部，成功则刷新专业表格并从可选项中移除；失败则显示错误消息
                if (departmentService.assignMajorToDepartment(selectedDeptCode, majorCode)) {
                    updateMajorTable(selectedDeptCode);
                    model.removeRow(row);  // 从可选列表中移除
                }
            }
        }, "添加");

        // 设置专业表格操作列的渲染器和编辑器
        table.getColumnModel().getColumn(2)
                .setCellRenderer(buttonEditor.getRenderer());
        table.getColumnModel().getColumn(2)
                .setCellEditor(buttonEditor);

        // 为搜索框添加DocumentListener，实现实时搜索功能
        searchField.getDocument().addDocumentListener(new DocumentListener() {
            private void search() {
                String text = searchField.getText().toLowerCase(); // 获取搜索文本
                TableRowSorter<DefaultTableModel> sorter =
                        new TableRowSorter<>(model); // 创建表格排序器
                if (!text.isEmpty()) {
                    // 如果搜索文本不为空，设置RowFilter以进行过滤
                    sorter.setRowFilter(RowFilter.regexFilter("(?i)" + text));
                } else {
                    // 如果搜索文本为空，清除过滤器
                    sorter.setRowFilter(null);
                }
                table.setRowSorter(sorter); // 将排序器应用到表格
            }

            @Override
            public void insertUpdate(DocumentEvent e) { search(); } // 文档插入时进行搜索
            @Override
            public void removeUpdate(DocumentEvent e) { search(); } // 文档删除时进行搜索
            @Override
            public void changedUpdate(DocumentEvent e) { search(); } // 文档改变时进行搜索
        });

        // 将带有滚动条的专业表格添加到对话框
        dialog.add(new JScrollPane(table), BorderLayout.CENTER);

        // 创建按钮面板，包含关闭按钮
        JPanel buttonPanel = new JPanel();
        JButton closeButton = new JButton("关闭");
        closeButton.setFont(BUTTON_FONT);
        closeButton.setPreferredSize(new Dimension(90, 32));
        closeButton.addActionListener(e -> dialog.dispose()); // 为关闭按钮添加事件监听器
        buttonPanel.add(closeButton);

        // 将按钮面板添加到对话框的底部
        dialog.add(buttonPanel, BorderLayout.SOUTH);

        // 设置对话框大小和位置，并显示对话框
        dialog.setSize(600, 400);
        dialog.setLocationRelativeTo(this);
        dialog.setVisible(true);
    }

    /**
     * 辅助方法，用于向表单面板中添加表单项。
     * @param panel 表单面板
     * @param label 表单项标签
     * @param field 表单项输入组件
     * @param gbc GridBagConstraints对象
     * @param row 表单项所在的行
     */
    private void addFormField(JPanel panel, String label, JComponent field,
                              GridBagConstraints gbc, int row) {
        gbc.gridx = 0; // 设置标签所在列
        gbc.gridy = row; // 设置标签所在行
        gbc.anchor = GridBagConstraints.EAST; // 设置标签对齐方式
        JLabel jLabel = new JLabel(label); // 创建标签
        jLabel.setFont(CONTENT_FONT); // 设置标签字体
        panel.add(jLabel, gbc); // 将标签添加到面板

        gbc.gridx = 1; // 设置输入组件所在列
        gbc.anchor = GridBagConstraints.WEST; // 设置输入组件对齐方式
        gbc.weightx = 1.0; // 设置输入组件权重
        panel.add(field, gbc); // 将输入组件添加到面板
        gbc.weightx = 0.0; // 重置输入组件权重
    }

    /**
     * 根据系部代码加载该系部下的所有专业数据到指定的表格模型。
     * @param deptCode 系部代码
     * @param tableModel 表格模型
     */
    private void loadMajorData(String deptCode, DefaultTableModel tableModel) {
        tableModel.setRowCount(0); // 清空表格模型
        List<Major> majors = departmentService.getDepartmentMajors(deptCode); // 获取该系部下的所有专业
        for (Major major : majors) {
            Object[] rowData = {
                    major.getMajorCode(),
                    major.getMajorName(),
                    "删除"
            };
            tableModel.addRow(rowData); // 将专业信息添加到表格模型
        }
    }
}
